/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package CalculatorActions;


import javax.swing.JRadioButton;

/**
 *
 * @author Mauro
 */
public class Logic {

    //Metodo que verifica si la tecla presionada puede ser recibida y agregada a la calculadora.
    public String KeyPressed(String display,String boton){
        if(display.indexOf("E")==-1){
            if(boton.equals(",")){
                int coma=display.lastIndexOf(boton);
                int ultimoOperador=buscarUltimoOperador(display);
                if(((ultimoOperador>coma)&&(display.length()>ultimoOperador+1))||
                        ((ultimoOperador==coma)&&(coma==-1)&&(display.length()>ultimoOperador+1))){
                    display=display+boton;
                }
            } else {
                if((boton.equals("+"))||(boton.equals("-"))||(boton.equals("*"))||(boton.equals("/"))){
                    int ultimo=buscarUltimoOperador(display);
                    if(display.length()!=ultimo+1){
                        int coma=display.lastIndexOf(",");
                        if(coma==display.length()-1){
                            display=display+"0";
                        }
                        display=display+boton;
                    }
                } else {
                    display=display+boton;
                }
            }
        }
        return display;
    }

    //Metodo que elimina todos los caracteres posteriores al ultimo operador.
    //En caso de que no exista devuulve un string vacio.
    public String keyCePressed(String display){
        int porlas=buscarUltimoOperador(display);
        if(porlas>-1){
            display=display.substring(0, porlas);
        } else {
            display="";
        }
        return display;
    }

    //Metodo que elimina el ultimo caracter de un string en caso de que no sea vacio.
    public String borrarCaracter(String oldDisplay){
        int largo=oldDisplay.length();
        if(largo>0){
            oldDisplay=oldDisplay.substring(0, largo-1);
        }
        return oldDisplay;
    }

    //Recibe un string y reconoce en caso de que sea una operacion la resuelve.
    public static String resolver(String display) {
        String[] array = new String[display.length()];
        char caracter;
        String acumulador = "";

        for (int i = 0; i < display.length(); i++) {
            caracter = display.charAt(i);
            if (caracter == '+' || caracter == '-' || caracter == '/' || caracter == '*') {
                array[i - 1] = acumulador;
                array[i] = caracter + "";
                acumulador = "";
            } else {
                acumulador = acumulador + caracter + "";
            }
        }
        array[display.length() - 1] = acumulador;

        array = eliminarEspaciosNull(array);

        array = realizarCalculos(array);

        return array[0];
    }

    //Elimina los String que son nulos de un vector de string.
    public static String[] eliminarEspaciosNull(String[] texto) {

        for (int i = 0; i < texto.length; i++) {
            while (texto[i] == null) {
                for (int j = i; j < texto.length - 1; j++) {
                    texto[j] = texto[j + 1];
                    texto[j + 1] = "";
                }
            }
        }
        return texto;
    }

    //Elimina los espacios libres de cada posicion de un vector de string.
    public static String[] eliminarEspacios(String[] texto) {
        for (int i = 0; i < texto.length; i++) {
            if (texto[i].equals("")) {
                for (int j = i; j < texto.length - 1; j++) {
                    texto[j] = texto[j + 1];
                    texto[j + 1] = "";
                }
            }
        }
        for (int i = 0; i < texto.length; i++) {
            if (texto[i].equals("")) {
                for (int j = i; j < texto.length - 1; j++) {
                    texto[j] = texto[j + 1];
                    texto[j + 1] = "";
                }
            }
        }
        return texto;
    }

    //Realiza los calculos segun los diferentes operadores.
    public static String[] realizarCalculos(String[] arrayRecibido) {
        String array[] = arrayRecibido;
        for (int i = 0; i < array.length - 1; i++) {
            if (array[i].equals("*")) {
                array[i - 1] = realizarOperacion(array[i - 1], array[i + 1], array[i]);
                array[i] = "";
                array[i + 1] = "";
                array = eliminarEspacios(array);
                i--;
            }
        }
        for (int i = 0; i < array.length - 1; i++) {
            if (array[i].equals("/")) {
                array[i - 1] = realizarOperacion(array[i - 1], array[i + 1], array[i]);
                array[i] = "";
                array[i + 1] = "";
                array = eliminarEspacios(array);
                i--;
            }
        }
        for (int i = 0; i < array.length - 1; i++) {
            if (array[i].equals("-")) {
                array[i - 1] = realizarOperacion(array[i - 1], array[i + 1], array[i]);
                array[i] = "";
                array[i + 1] = "";
                array = eliminarEspacios(array);
                i--;
            }
        }
        for (int i = 0; i < array.length - 1; i++) {
            if (array[i].equals("+")) {
                array[i - 1] = realizarOperacion(array[i - 1], array[i + 1], array[i]);
                array[i] = "";
                array[i + 1] = "";
                array = eliminarEspacios(array);
                i--;
            }
        }

        return array;
    }

    //Dado dos operedores y un operando, realiza la operacion indicada.
    public static String realizarOperacion(String a, String b, String operador) {
        Double a1 = Double.parseDouble(a);
        Double a2 = Double.parseDouble(b);

        if (operador.equals("+")) {
            return ((a1 + a2) + "");
        }
        if (operador.equals("*")) {
            return ((a1 * a2) + "");
        }
        if (operador.equals("-")) {
            return ((a1 - a2) + "");
        }
        if (operador.equals("/")) {
            return ((a1 / a2) + "");
        }

        return null;
    }
    
    //Metodo que recibe un String de formato numerico, le cambia la base y le devuleve como String.
    //Maneja los errores. En caso de encontrarlos devuelve la informacion pertinente.
    public String cambiarNumerico(String display,java.awt.event.ActionEvent evt){
        JRadioButton boton=(JRadioButton)evt.getSource();
        String tipo=boton.getText();
        Integer number;
        if(buscarUltimoOperador(display)<0){
            try{
                number=Integer.parseInt(display);
                if(tipo.equals("Decimal")){
                    return  number.toString();
                } else if (tipo.equals("Binario")){
                    return Integer.toBinaryString(number);
                } else if (tipo.equals("Hexadecimal")){
                    return Integer.toHexString(number);
                }
            }catch(Exception e){
                int j=Integer.MAX_VALUE;
                return "ERROR:Numero demasiado grande. Debe ser menor a: "+j+". vuelva a formato decimal y limpia el display para continuar.";
            }
        }
        return "ERROR:No se puede convertir con operadores. vuelva a formato decimal Limpia el display para continuar.";
    }

    //Metodo que controla el cambio de formato numerico de la calculadora.
    private int buscarUltimoOperador(String display) {
        int mas=display.lastIndexOf("+");
        int menos=display.lastIndexOf("-");
        int por=display.lastIndexOf("*");
        int div=display.lastIndexOf("/");
        int[] indices={mas,menos,por,div};
        int max=mas;
        for(int i=1;i<4;i++){
            if (indices[i]>max){
                max=indices[i];
            }
        }
        return max;
    }

}
